﻿/***  File Header  ************************************************************/
/**
*  Dic.cpp
*
* P4thディクショナリ
*  shozo fukuda
*    作成 Sat Mar 31 23:27:28 2012
*    修正 $Date:$
* System   Generic <br>
*
*******************************************************************************/

/*******************************************************************************
* IMPORTS:
*******************************************************************************/
#include "Dic.h"  /* 呼出用 */

/*******************************************************************************
* CONSTANT:
*******************************************************************************/

/*******************************************************************************
* TYPE:
*******************************************************************************/

/*******************************************************************************
* REGULAR C-FUNCTION:
*******************************************************************************/
void f_unknown(P4th* p4th);
void f_lit(P4th* p4th);
void f_colon(P4th* p4th);
void f_docol(P4th* p4th);
void f_semicolon(P4th* p4th);
void f_immediate(P4th* p4th);
void f_constant(P4th* p4th);
void f_doconst(P4th* p4th);
void f_variable(P4th* p4th);
void f_dovar(P4th* p4th);
void f_dup(P4th* p4th);
void f_qdup(P4th* p4th);
void f_drop(P4th* p4th);
void f_swap(P4th* p4th);
void f_over(P4th* p4th);
void f_rot(P4th* p4th);
void f_pick(P4th* p4th);
void f_2dup(P4th* p4th);
void f_2drop(P4th* p4th);
void f_2over(P4th* p4th);
void f_2swap(P4th* p4th);
void f_depth(P4th* p4th);
void f_dot(P4th* p4th);
void f_emit(P4th* p4th);
void f_space(P4th* p4th);
void f_spaces(P4th* p4th);
void f_cr(P4th* p4th);
void f_dot_2hex(P4th* p4th);
void f_dot_4hex(P4th* p4th);
void f_dot_8hex(P4th* p4th);
void f_fetch(P4th* p4th);
void f_store(P4th* p4th);
void f_plus_store(P4th* p4th);
void f_c_fetch(P4th* p4th);
void f_c_store(P4th* p4th);
void f_add(P4th* p4th);
void f_sub(P4th* p4th);
void f_mul(P4th* p4th);
void f_div(P4th* p4th);
void f_mod(P4th* p4th);
void f_incr(P4th* p4th);
void f_decr(P4th* p4th);
void f_negate(P4th* p4th);
void f_abs(P4th* p4th);
void f_min(P4th* p4th);
void f_max(P4th* p4th);
void f_and(P4th* p4th);
void f_or(P4th* p4th);
void f_xor(P4th* p4th);
void f_eq(P4th* p4th);
void f_lt(P4th* p4th);
void f_gt(P4th* p4th);
void f_zeq(P4th* p4th);
void f_zlt(P4th* p4th);
void f_zgt(P4th* p4th);
void f_to_r(P4th* p4th);
void f_from_r(P4th* p4th);
void f_r_fetch(P4th* p4th);
void f_0branch(P4th* p4th);
void f_branch(P4th* p4th);
void f_if(P4th* p4th);
void f_else(P4th* p4th);
void f_then(P4th* p4th);
void f_begin(P4th* p4th);
void f_until(P4th* p4th);
void f_while(P4th* p4th);
void f_repeat(P4th* p4th);
void f_do(P4th* p4th);
void f_xdo(P4th* p4th);
void f_loop(P4th* p4th);
void f_xloop(P4th* p4th);
void f_ploop(P4th* p4th);
void f_xploop(P4th* p4th);
void f_i(P4th* p4th);
void f_j(P4th* p4th);
void f_exit(P4th* p4th);
void f_version(P4th* p4th);
void f_dumpnew(P4th* p4th);

/*******************************************************************************
* GLOBAL VARIABLE:
*******************************************************************************/
static P4thFunc _func[78] = {
	f_unknown,
	f_lit,
	f_colon,
	f_docol,
	f_semicolon,
	f_immediate,
	f_constant,
	f_doconst,
	f_variable,
	f_dovar,
	f_dup,
	f_qdup,
	f_drop,
	f_swap,
	f_over,
	f_rot,
	f_pick,
	f_2dup,
	f_2drop,
	f_2over,
	f_2swap,
	f_depth,
	f_dot,
	f_emit,
	f_space,
	f_spaces,
	f_cr,
	f_dot_2hex,
	f_dot_4hex,
	f_dot_8hex,
	f_fetch,
	f_store,
	f_plus_store,
	f_c_fetch,
	f_c_store,
	f_add,
	f_sub,
	f_mul,
	f_div,
	f_mod,
	f_incr,
	f_decr,
	f_negate,
	f_abs,
	f_min,
	f_max,
	f_and,
	f_or,
	f_xor,
	f_eq,
	f_lt,
	f_gt,
	f_zeq,
	f_zlt,
	f_zgt,
	f_to_r,
	f_from_r,
	f_r_fetch,
	f_0branch,
	f_branch,
	f_if,
	f_else,
	f_then,
	f_begin,
	f_until,
	f_while,
	f_repeat,
	f_do,
	f_xdo,
	f_loop,
	f_xloop,
	f_ploop,
	f_xploop,
	f_i,
	f_j,
	f_exit,
	f_version,
	f_dumpnew,
};
P4thFunc* P4th::_Func = _func;

static UCHAR _name[295] = {
	   0, /*NAMELESS*/
	   1, ':',
	   1, ';',
	   9, 'I','M','M','E','D','I','A','T','E',
	   8, 'C','O','N','S','T','A','N','T',
	   8, 'V','A','R','I','A','B','L','E',
	   3, 'D','U','P',
	   4, '\?','D','U','P',
	   4, 'D','R','O','P',
	   4, 'S','W','A','P',
	   4, 'O','V','E','R',
	   3, 'R','O','T',
	   4, 'P','I','C','K',
	   4, '2','D','U','P',
	   5, '2','D','R','O','P',
	   5, '2','O','V','E','R',
	   5, '2','S','W','A','P',
	   5, 'D','E','P','T','H',
	   1, '.',
	   4, 'E','M','I','T',
	   5, 'S','P','A','C','E',
	   6, 'S','P','A','C','E','S',
	   2, 'C','R',
	   5, '.','2','H','E','X',
	   5, '.','4','H','E','X',
	   5, '.','8','H','E','X',
	   1, '@',
	   1, '!',
	   2, '+','!',
	   2, 'C','@',
	   2, 'C','!',
	   1, '+',
	   1, '-',
	   1, '*',
	   1, '/',
	   3, 'M','O','D',
	   2, '1','+',
	   2, '1','-',
	   6, 'N','E','G','A','T','E',
	   3, 'A','B','S',
	   3, 'M','I','N',
	   3, 'M','A','X',
	   3, 'A','N','D',
	   2, 'O','R',
	   3, 'X','O','R',
	   1, '=',
	   1, '<',
	   1, '>',
	   2, '0','=',
	   2, '0','<',
	   2, '0','>',
	   2, '>','R',
	   2, 'R','>',
	   2, 'R','@',
	   2, 'I','F',
	   4, 'E','L','S','E',
	   4, 'T','H','E','N',
	   5, 'B','E','G','I','N',
	   5, 'U','N','T','I','L',
	   5, 'W','H','I','L','E',
	   6, 'R','E','P','E','A','T',
	   2, 'D','O',
	   4, 'L','O','O','P',
	   5, '+','L','O','O','P',
	   1, 'I',
	   1, 'J',
	   4, 'E','X','I','T',
	   7, 'V','E','R','S','I','O','N',
	   4, 'D','U','M','P',
};
UCHAR* P4th::_Name = _name;
const long P4th::_NameFence = 295;

static Code _code[211] = {
	            S_UNKNOWN,
	            S_LIT,
	   0,    1, S_COLON,
	   2,    3, S_SEMICOLON,
	   5,    5, S_IMMEDIATE,
	   8,   15, S_CONSTANT,
	  11,   24, S_VARIABLE,
	  14,   33, S_DUP,
	  17,   37, S_QDUP,
	  20,   42, S_DROP,
	  23,   47, S_SWAP,
	  26,   52, S_OVER,
	  29,   57, S_ROT,
	  32,   61, S_PICK,
	  35,   66, S_2DUP,
	  38,   71, S_2DROP,
	  41,   77, S_2OVER,
	  44,   83, S_2SWAP,
	  47,   89, S_DEPTH,
	  50,   95, S_DOT,
	  53,   97, S_EMIT,
	  56,  102, S_SPACE,
	  59,  108, S_SPACES,
	  62,  115, S_CR,
	  65,  118, S_DOT_2HEX,
	  68,  124, S_DOT_4HEX,
	  71,  130, S_DOT_8HEX,
	  74,  136, S_FETCH,
	  77,  138, S_STORE,
	  80,  140, S_PLUS_STORE,
	  83,  143, S_C_FETCH,
	  86,  146, S_C_STORE,
	  89,  149, S_ADD,
	  92,  151, S_SUB,
	  95,  153, S_MUL,
	  98,  155, S_DIV,
	 101,  157, S_MOD,
	 104,  161, S_INCR,
	 107,  164, S_DECR,
	 110,  167, S_NEGATE,
	 113,  174, S_ABS,
	 116,  178, S_MIN,
	 119,  182, S_MAX,
	 122,  186, S_AND,
	 125,  190, S_OR,
	 128,  193, S_XOR,
	 131,  197, S_EQ,
	 134,  199, S_LT,
	 137,  201, S_GT,
	 140,  203, S_ZEQ,
	 143,  206, S_ZLT,
	 146,  209, S_ZGT,
	 149,  212, S_TO_R,
	 152,  215, S_FROM_R,
	 155,  218, S_R_FETCH,
	            S_0BRANCH,
	            S_BRANCH,
	 158,  221, S_IF,
	 163,  224, S_ELSE,
	 166,  229, S_THEN,
	 169,  234, S_BEGIN,
	 172,  240, S_UNTIL,
	 175,  246, S_WHILE,
	 178,  252, S_REPEAT,
	 181,  259, S_DO,
	            S_XDO,
	 184,  262, S_LOOP,
	            S_XLOOP,
	 188,  267, S_PLOOP,
	            S_XPLOOP,
	 192,  273, S_I,
	 196,  275, S_J,
	 199,  277, S_EXIT,
	 202,  282, S_VERSION,
	 205,  290, S_DUMPNEW,
};
Code* P4th::_Code = _code;
const long P4th::_CodeFence = 211;



static P4thConst* _const[] = {

  0
};
P4thConst** P4th::_Const = _const;

/***  Revision Information  ****************************************************
*
$Log:$
*
*******************************************************************************/
